%--------------------------------------------------------------------------
function chromosome = generateSingleChromosome(M, num_modules_target, method, DSM, alpha)
    % 生成单个有效的染色体矩阵

    if num_modules_target < 1 || num_modules_target > M
        chromosome = [];
        return;
    end
    
    chromosome_matrix = zeros(num_modules_target, M); % 使用目标 num_modules 进行初始化

    if strcmp(method, 'random')
        for j = 1:M % 对于每个元素（列）
            chosen_module_idx = randi(num_modules_target); % 分配给随机模块
            chromosome_matrix(chosen_module_idx, j) = 1;
        end
    elseif strcmp(method, 'greedy_roulette')
        if nargin < 5 % nargin函数输入参数的数量。
            error('DSM and greedyThreshold are required for greedy_roulette method.');
        end

        all_elements = 1:M; % 创建一个数组 [1, 2, ..., M]，表示所有组件的编号
        assigned_elements = false(1, M); % 初始化一个逻辑向量（布尔数组），长度为 M；
        % assigned_elements(j) 表示第 j 个组件是否已经被分配给某个模块；
        % 初始值为 false，表示所有组件都未分配。
        current_module_idx = 0; % chromosome_matrix 中的行索引

        for m_count = 1:num_modules_target % 尝试创建 num_modules_target 个模块
            if current_module_idx >= num_modules_target || all(assigned_elements)
                break; % 如果所有模块都已填满或所有元素都已分配，则停止
            end
            
            current_module_idx = current_module_idx + 1;
            module_C_elements = []; % 初始化一个空数组，用于收集当前模块中要放入的组件编号，
            % 后续过程中会通过贪婪策略、DSM连接强度等方式逐步添加组件进来

            % --- Step 1: 为模块 C 随机选择一个初始元素 E1 ---
            unassigned_elements_pool = all_elements(~assigned_elements); % 筛选出 未分配的组件编号
            if isempty(unassigned_elements_pool) % 如果是空的，说明没有组件可用于新建模块
                current_module_idx = current_module_idx - 1; % 前面已经执行了 current_module_idx = current_module_idx + 1
                % 此时发现其实已经没有组件可用了，所以要撤销当前这个新模块编号的分配
                % 以保证 current_module_idx 始终指向一个有效的、实际存在的模块编号
                break; 
            end
            
            E1_idx = randi(length(unassigned_elements_pool)); %从未分配的组件中随机选择一个作为当前模块的起始元素
            E1 = unassigned_elements_pool(E1_idx);
            
            module_C_elements = [module_C_elements, E1]; % 向数组 module_C_elements 的末尾添加一个新元素 E1，
            % 并将结果重新赋值给 module_C_elements
            assigned_elements(E1) = true;
            chromosome_matrix(current_module_idx, E1) = 1;

            % --- Steps 2 & 3: 迭代地向模块 C 添加元素 ---
            while true
                unassigned_elements_pool = all_elements(~assigned_elements);
                if isempty(unassigned_elements_pool)
                    break; % 不再有元素需要分配到任何地方
                end

                candidate_elements_for_C = []; %用于存放那些“可能加入当前模块”的组件编号
                connection_strengths_for_C = []; % 用于存放每个候选组件与当前模块之间的总耦合强度；

                % 查找与 module_C_elements 连接的元素
                for unassigned_elem_idx = 1:length(unassigned_elements_pool)
                    % 遍历所有尚未分配的元素（potential_E2 表示待评估的那个元素）
                    potential_E2 = unassigned_elements_pool(unassigned_elem_idx);
                    connection_to_module_C = 0;
                    for elem_in_C_idx = 1:length(module_C_elements) % 遍历当前模块中已经分配的元素（记为 elem_in_C）
                        elem_in_C = module_C_elements(elem_in_C_idx);
                        % 假设 DSM(i,j) = 1（如果连通），否则为 0。
                        % 或者 DSM(i,j) 可以是一个强度值。
                        % 将potential_E2到module_C中所有元素的连接求和
                        connection_to_module_C = connection_to_module_C + DSM(potential_E2, elem_in_C) + DSM(elem_in_C, potential_E2);
                    end

                    required_connections = ceil(alpha * length(module_C_elements));
                    if connection_to_module_C >= required_connections
                        candidate_elements_for_C = [candidate_elements_for_C, potential_E2];
                        % 将符合条件的元素及其耦合强度加入候选列表
                        connection_strengths_for_C = [connection_strengths_for_C, connection_to_module_C];
                    end
                end

                if isempty(candidate_elements_for_C)
                    break; % 不再有元素符合该模块的条件
                end

                % E2 的轮盘选择
                if sum(connection_strengths_for_C) == 0 % 如果所有候选元素与当前模块的连接强度总和为 0
                    % 此时无法依据耦合强度进行判断，只能随机从候选中选择一个。
                    chosen_candidate_idx = randi(length(candidate_elements_for_C));
                else
                    probabilities = connection_strengths_for_C / sum(connection_strengths_for_C);
                    % 将每个候选元素的连接强度标准化为概率
                    cumulative_probs = cumsum(probabilities);
                    % 得到累计概率向量
                    r = rand(); %从 [0, 1] 之间随机抽一个数（均匀分布），这个数代表“轮盘上转到的刻度”。
                    chosen_candidate_idx = find(r <= cumulative_probs, 1, 'first');% 找到第一个累计概率大于等于 r 的位置
                    % 实际上就是“转盘在哪个区间停下来了”
                end
                
                E2 = candidate_elements_for_C(chosen_candidate_idx); % 从候选集合中拿到通过轮盘赌机制选出的元素 E2
                module_C_elements = [module_C_elements, E2]; % 把该元素加入当前正在构建的模块 C 的元素列表中
                assigned_elements(E2) = true; % 标记该元素为“已分配”，避免被其他模块重复使用
                chromosome_matrix(current_module_idx, E2) = 1; % 将当前模块与该元素的关联写入
                % 模块划分编码矩阵中（典型 DSM 模块分配矩阵形式）；
            end % 当 true 时结束，表示添加到当前模块 C
        end % 结束创建模块的循环

        % --- 处理未分配的元素（如果有） ---
        % 如果并非所有元素都已分配（例如，由于阈值或最初针对的模块不够）
        % 或者如果没有使用所有的 num_modules_target 行。
        unassigned_indices = find(~assigned_elements);
        if ~isempty(unassigned_indices)
            for elem_idx = unassigned_indices
                % 分配给随机现有模块，如果模块数量少于 num_modules_target，则创建新模块
                if current_module_idx == 0 % 根本没有创建模块（边缘情况）
                    current_module_idx = 1; % 启动第一个模块
                    if size(chromosome_matrix,1) == 0 % 确保矩阵存在
                         chromosome_matrix = zeros(1, M);
                    end
                end
                
                % 如果创建的模块数量少于 num_modules_target，则优先创建新的模块
                if current_module_idx < num_modules_target
                     current_module_idx = current_module_idx + 1;
                     chromosome_matrix(current_module_idx, elem_idx) = 1;
                     assigned_elements(elem_idx) = true;
                else % 分配给随机*现有*的已填充模块
                    if current_module_idx > 0
                         target_row = randi(min(current_module_idx, num_modules_target)); % Ensure valid row
                         chromosome_matrix(target_row, elem_idx) = 1;
                         assigned_elements(elem_idx) = true;
                    else % 如果按照上述方法处理，就不会发生
                         warning('Greedy init: Unassigned element could not be placed.');
                    end
                end
            end
        end
        
        % 如果实际创建的模块数量少于 num_modules_target，则修剪未使用的行
        % 并使用。
        active_rows = find(sum(chromosome_matrix, 2) > 0); % 查找不为空的模块
        chromosome_matrix = chromosome_matrix(active_rows, :); % 保留不为空的模块
        if isempty(chromosome_matrix) && M > 0 % 如果所有行都为空，则创建一个默认模块
            chromosome_matrix = ones(1,M); % 创建一个默认模块，即将所有元素都分配到一个模块中
        end


    else
        error('Unknown chromosome generation method.');
    end

    chromosome = chromosome_matrix; % 分配最终矩阵

    % Validate: 确保每列恰好有一个“1”
    if ~isempty(chromosome) % 判断染色体是否为空
        colSums = sum(chromosome, 1); % 计算每列的和
        if ~all(colSums == 1) % 判断是否存在某列和不等于 1 的情况
            warning('Chromosome validation failed during generation (method: %s). Attempting fix...', method);
            num_actual_modules = size(chromosome,1); % 获取染色体矩阵的模块数
            if num_actual_modules == 0 % 贪婪后处理完全空的染色体
                warning('Greedy init resulted in empty chromosome, re-initializing randomly.');
                chromosome = zeros(num_modules_target, M); % 创建一个空的染色体矩阵，准备重新随机分配元素。
                for j = 1:M
                     chosen_module_idx = randi(num_modules_target);
                     chromosome(chosen_module_idx, j) = 1;
                end
            else
                for j = find(colSums ~= 1) % 找到所有“列和不等于1”的列索引
                     chromosome(:, j) = 0; % 将该列清空，即把该元素从所有模块中移除
                     chosen_module_idx = randi(num_actual_modules); % 随机分配到现有模块
                     chromosome(chosen_module_idx, j) = 1;
                end
            end
             if ~all(sum(chromosome, 1) == 1) % 检查是否每列的和都为1， 如果有任何列不满足这一条件
                  error('Chromosome validation failed even after fix attempt for method: %s.', method);
                  chromosome = []; % 发生致命错误时返回空
             end
        end
    elseif M > 0 % 染色体是空的，但不应该如此
        warning('Chromosome generation resulted in empty matrix (method: %s), re-initializing randomly for safety.', method);
        chromosome = zeros(num_modules_target, M);
        for j = 1:M
             chosen_module_idx = randi(num_modules_target);
             chromosome(chosen_module_idx, j) = 1;
        end
    end
end